package com.common.utils;

import java.text.DecimalFormat;
import java.text.NumberFormat;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 数值处理的工具类
 * @author lj
 * @date 2017年5月24日 下午1:28:53
 */
public class NumberUtils extends org.apache.commons.lang3.math.NumberUtils{
	
	private static final Logger logger = LoggerFactory.getLogger(NumberUtils.class);
	
	/**
	 * 返回两个int值中较大的值。 例： maxInt(5,6); // 返回值为6
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	public static int maxInt(int a, int b) {
		return a > b ? a : b;
	}

	/**
	 * 返回两个int值中较小的值。 例： maxInt(5,6); // 返回值为5
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	public static int minInt(int a, int b) {
		return a < b ? a : b;
	}
	
	/**
	 * 得到 double 类型
	 * 
	 * @param t
	 * @return
	 */
	public static double getDoubleData(Object t) {
		if (t == null || ((String) t).trim().equals(""))
			return 0;
		try {
			double ret = Double.parseDouble((String) t);
			return ret;
		} catch (Exception ex) {
			System.out.println(ex.toString() + t.toString());
		}
		return 0;
	}
	
	/**
	 * 格式化数字字符串为特定格式的字符串.
	 * 
	 * @param String
	 *            s 原有的数字字符串
	 * @param int
	 *            dot 后跟小数点位数
	 * @return String 返回特定格式的字符串
	 */
	public static String formatNumber(String s, int dot) {
		double d;
		if (s == null)
			return "";
		try {
			d = Double.parseDouble(s);
		} catch (NumberFormatException e) {
			logger.debug("{}",e.getMessage());
			//logger.error(e);
			return s;
		}
		NumberFormat nf = NumberFormat.getInstance();
		nf.setMinimumFractionDigits(dot);
		nf.setMaximumFractionDigits(dot);
		return nf.format(d);
	}
	
	/**
	 * 格式化double类型为特定格式的字符串.
	 * 
	 * @param double
	 *            d 双精度数字
	 * @param int
	 *            dot 后跟小数点位数
	 * @return String 返回特定格式的字符串
	 */
	public static String formatNumber(double d, int dot) {
		NumberFormat nf = NumberFormat.getInstance();
		nf.setMinimumFractionDigits(dot);
		nf.setMaximumFractionDigits(dot);
		return nf.format(d);
	}

	/**
	 * 格式化double类型为特定格式的.不带千位分隔符
	 * 
	 * @param double
	 *            d 双精度数字
	 * @param int
	 *            dot 后跟小数点位数
	 * @return String 返回特定格式的字符串
	 */
	public static String formatDecimal(double d, int dot) {
		NumberFormat nf = NumberFormat.getInstance();
		DecimalFormat df = (DecimalFormat) nf;
		df.setMinimumFractionDigits(dot);
		df.setMaximumFractionDigits(dot);
		String pattern = "#0";
		if (dot > 0) {
			pattern += ".";
			for (int i = 0; i < dot; i++) {
				pattern += "0";
			}
		}
		df.applyPattern(pattern);
		df.setDecimalSeparatorAlwaysShown(false);
		return df.format(d);
	}

	/**
	 * 格式化金额
	 */
	public static String formatMoney(double d) {
		return formatDecimal(d, 2);
	}

	/**
	 * 格式化利率
	 */
	public static String formatIntRate(double d) {
		return formatDecimal(d, 8);
	}

	/**
	 * 格式化double类型为特定格式的字符串.
	 * 
	 * @param double
	 *            d 双精度数字
	 * @param int
	 *            dot 后跟小数点位数
	 * @param int
	 *            type 0-不进行转换,1-百分数计算,2-除10000
	 * @return String 返回特定格式的字符串
	 */
	public static String formatNumber(String s, int dot, int type) {
		if (type == 0)
			return formatNumber(s, dot);
		if (type == 1) {
			double d;
			try {
				d = Double.parseDouble(s);
			} catch (NumberFormatException e) {
				logger.debug("{}", e);
				return s;
			}
			d = d * 100;
			return formatNumber(d, dot);
		}
		if (type == 2) {
			double d;
			try {
				d = Double.parseDouble(s);
			} catch (NumberFormatException e) {
				logger.debug("{}",e);
				return s;
			}
			d = d / 10000;
			return formatNumber(d, dot);
		}
		return s;
	}

	/**
	 * 格式化String为double型，如果字符串为空，返回0.
	 * 
	 * @param String
	 *            s 双精度数字
	 * @return double 返回double类型数值
	 */
	public static double parseDouble(String s) {
		double d = 0;
		if (s != null) {
			try {
				d = Double.parseDouble(s);
			} catch (NumberFormatException e) {
				try {
					String t = s.replaceAll(",", "");
					d = Double.parseDouble(t);
				} catch (NumberFormatException e2) {
					d = 0;
					logger.debug(e.getMessage());
				}
			}
		}
		return d;
	}

	/**
	 * 格式化String为float型，如果字符串为空，返回0.
	 * 
	 * @param String
	 *            s 双精度数字
	 * @return float 返回float类型数值
	 */
	public static float parseFloat(String s) {
		float f = 0;
		if (s != null) {
			try {
				f = Float.parseFloat(s);
			} catch (NumberFormatException e) {
				f = 0;
				logger.debug(e.getMessage());
			}
		}
		return f;
	}

	/**
	 * 格式化String为int型，如果字符串为空，返回0.
	 * 
	 * @param String
	 *            s 双精度数字
	 * @return int 返回int类型数值
	 */
	public static int parseInt(String s) {
		int i = 0;
		if (s != null) {
			s = s.trim();
			try {
				i = Integer.parseInt(s);
			} catch (NumberFormatException e) {
				i = 0;
				double t = parseDouble(s);
				if (t != 0) {
					i = (int) t;
				}
				logger.debug(e.getMessage());
			}
		}
		return i;
	}

	/**
	 * 取double的整数部分
	 * 
	 * @param d
	 * @return
	 */
	public static int getIntPart(double d) {
		String s = Double.toString(d);
		int i = s.indexOf(".");
		if (i < 0) {
			return parseInt(s);
		}
		return parseInt(s.substring(0, i));
	}
	
	/**
	 * 格式化数字String，把其中的逗号去掉，如果字符串为空，返回0.
	 * 
	 * @param String
	 *            s 双精度数字
	 * @return String 返回新的格式字符串
	 */
	public static String StringConvertor(String s) {
		StringBuffer bf = new StringBuffer();
		if (s != null) {
			for (int i = 0; i < s.length(); i++) {
				if (s.charAt(i) == ',')
					continue;
				else
					bf.append(s.charAt(i));
			}
		}
		return bf.toString();
	}
	
	/**
	 * 
	 * @param d
	 * @return
	 */
	public static boolean isZero(double d) {
		if (Math.abs(d) < 0.0000000001)
			return true;
		else
			return false;
	}
	
	/**
	 * 
	 * @param d
	 * @return
	 */
	public static double getAmtPart(double d, double part, int k) {
		double a = d * part / k;
		Double c = new Double(a);
		int b = c.intValue();
		a = 1.00 * b * k;
		return a;
	}
	
}
